import java.awt.List;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Collections;
import java.util.GregorianCalendar;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Vector;

import javax.swing.JTextField;

public class Controleur implements Serializable{
	/**
	 * 
	 */
	//private static final long serialVersionUID = 6136418870870522173L;

	/**
	 * La classe Controleur est unique pour tous les cas d'utilisation
	 * Elle est egalement la classe "application" qui gere l'ensemble des objets de l'appli
	 */	
	// ************************************************************************************************************
		// Attributs
		// ************************************************************************************************************
		private int numDerCompte ;  //Dernier numro de compte (permet de gnrer automatiquement les numros de comptes
		private int numDerMouv;
		// Attributs d'Association
		// Ensemble des clients de la banque
		private HashMap<String, ClientPhysique> _clients; 
		private HashMap<Integer, ComptePerso> _comptes;
		private HashMap<Integer, CompteSociete> _comptesSociete;
		
		private HashMap<String, Mandataire> _mandataires; 
		private HashMap<String, Societe> _societes;
		
		private HashMap<Integer, Retrait> _retraits; 
		private HashMap<Integer, Depot> _depots;
		
		// les differentes fenetres pour chaque fonctionnalite
		private VueMenuBanque _vueMenuBanque = null;
		
		// une seule fenetre est active  la fois; les autres sont null.
		// permet de connaitre l'etat des fenetres de l'interface
		private VueNouvClient _vueNouvClient = null;
		private VueNouvCompte _vueNouvCompte = null;
		private VueComptePerso _vueComptePerso = null;
		
		private VueNouvSociete _vueNouvSociete = null;
		private VueNouvCompteSociete _vueNouvCompteSociete = null;
		private VueCompteSociete _vueCompteSociete = null;
		private VueNouvMandataire _vueNouvMandataire = null;
		
		private VueDepot _vueDepot = null;
		private VueRetrait _vueRetrait = null;

		private VueExtraitCompte _vueExtraitCompte = null;
		// ************************************************************************************************************
		// Constructeur
		// ************************************************************************************************************

		public Controleur() {
			this.setNumDerCompte(0);
			this.setNumDermouv(0);
			this.setClients(new HashMap<String, ClientPhysique>());
			this.setComptes(new HashMap<Integer, ComptePerso>());
			this.setComptesSociete(new HashMap<Integer, CompteSociete>());
			this.setSocietes(new HashMap<String, Societe>());
			this.setMandataires(new HashMap<String, Mandataire>());
		} // Fin Controleur

		// ------------------------------------------------------------------------------------------------------------
		// Affecteurs
		
		private void setNumDermouv(int i) {
			numDerMouv = i;
		}

		private void setNumDerCompte(int num){
			numDerCompte = num;
		}
		
		/**
		 * Ajoute un client  l'ensemble des clients de la banque.
		 * @param client 	Client  ajouter
		 * @param np 		Nom + Prnom de ce client
		 */
		
		
		private void setClient(ClientPhysique client, String np) {
			this.getClients().put(np, client);
		} // Fin setClient
		
		private void setSociete(Societe societe, String numS) {
			this.getSocietes().put(numS, societe);
		} // Fin setClient
		
		private void setMandataire(Mandataire mandataire, String nom) {
			this.getMandataires().put(nom, mandataire);
		} // Fin setClient
		/**
		 * Initialise l'attribut clients  l'ensemble des clients de la banque.
		 * @param clients hashtable de clients a affecter
		 */
		private void setClients(HashMap<String, ClientPhysique> clients) {
			_clients = clients;
		}// Fin setClients
		
		
		/**
		 * Initialise l'attribut mandataires l'ensemble des mandataires de la banque.
		 * @param mandataires hashtable de mandataires a affecter
		 */
		private void setMandataires(HashMap<String, Mandataire> mandataires) {
			_mandataires = mandataires;
		}// Fin setClients
		
		
		private void setRetraits(HashMap<Integer, Retrait> retraits) {
			_retraits = retraits;
		}// Fin setClients
		
		private void setDepots(HashMap<Integer, Depot> depots) {
			_depots = depots;
		}// Fin setClients
		/**
		 * Initialise l'attribut Societe l'ensemble des societes de la banque.
		 * @param societe hashtable de societe a affecter
		 */
		private void setSocietes(HashMap<String, Societe> societes) {
			_societes = societes;
		}// Fin setClients
		
		/**
		 * Ajoute un compte  l'ensemble des comptes de la banque.
		 * @param compte 	Compte  ajouter
		 * @param n		Numro de ce compte
		 */
		private void setCompte(ComptePerso compte, Integer n) {
			this.getComptes().put(n, compte);
		} // Fin setComptes

		/**
		 * Initialise l'attribut comptes  l'ensemble des comptes de la banque.
		 * @param comptes hashtable de comptes a affecter
		 */
		private void setComptes(HashMap<Integer, ComptePerso> comptes) {
			_comptes = comptes;
		}// Fin setComptes
		
		private void setCompteSociete(CompteSociete compte, Integer n) {
			this.getComptesSociete().put(n, compte);
		} // Fin setComptes

		/**
		 * Initialise l'attribut comptes  l'ensemble des comptes de la banque.
		 * @param comptes hashtable de comptes a affecter
		 */
		private void setComptesSociete(HashMap<Integer, CompteSociete> comptes) {
			_comptesSociete = comptes;
		}// Fin setComptes
		/**
		 * Initialise la vue  affecter
		 * @param vue  la vue a affecter
		 */
		private void setVueMenuBanque(VueMenuBanque vue) {
			_vueMenuBanque = vue;
		}// Fin getVueVueMenuBiblio
		
		private void setVueNouvClient(VueNouvClient vue) {
			_vueNouvClient = vue;
		}// Fin setVueVueNouvClient
		
		private void setVueNouvCompte(VueNouvCompte vue) {
			_vueNouvCompte = vue;
		}// Fin setVueVueNouvCompte
		
		private void setVueComptePerso(VueComptePerso vue) {
			_vueComptePerso = vue;
		}// Fin setVueVueNouvCompte
		
		private void setVueNouvSociete(VueNouvSociete vue) {
			_vueNouvSociete = vue;
		}// Fin setVueVueNouvClient
		
		private void setVueNouvCompteSociete(VueNouvCompteSociete vue) {
			_vueNouvCompteSociete = vue;
		}// Fin setVueVueNouvCompte
		
		private void setVueCompteSociete(VueCompteSociete vue) {
			_vueCompteSociete = vue;
		}// Fin setVueVueNouvCompte
		
		private void setVueNouvMandataire(VueNouvMandataire vue) {
			_vueNouvMandataire = vue;
		}// Fin setVueVueNouvCompte
		
		private void setVueDepot(VueDepot vue) {
			_vueDepot = vue;
		}// Fin setVueVueNouvCompte
		
		private void setVueRetrait(VueRetrait vue) {
			_vueRetrait = vue;
		}// Fin setVueVueNouvCompte
		// ------------------------------------------------------------------------------------------------------------
		// Accesseurs
		
		public int getNumDerCompte(){
			return numDerCompte;
		}
		
		public int getNumDerMouv(){
			return numDerMouv;
		}
		
		private HashMap<String, Societe> getSocietes() {
			return _societes;
		}
		
		private HashMap<Integer, Depot> getDepots() {
			return _depots;
		}
		
		private HashMap<Integer, Retrait> getRetraits() {
			return _retraits;
		}
		
		private Societe getSociete(String nom){
			return this.getSocietes().get(nom);
		}
		
		private HashMap<String, Mandataire> getMandataires() {
			return _mandataires;
		}
		
		private Mandataire getMandataire(String np){
			return this.getMandataires().get(np);
		}
		
		/**
		 * @return ensemble des clients de la banque
		 */
		private HashMap<String, ClientPhysique> getClients() {
			return _clients;
		}// Fin getClients

		/**
		 * Acces  un client par son nom + prnom
		 * @param np 	le nom+prenom du client recherch
		 * @return le client qui a le np indiqu
		 */
		private ClientPhysique getClient(String np) {
			return this.getClients().get(np);
		} // Fin getClient
		

		/**
		 * @return ensemble des comptes de la banque
		 */
		private HashMap<Integer, ComptePerso> getComptes() {
			return _comptes;
		}// Fin getCompte
		
		private HashMap<Integer, CompteSociete> getComptesSociete() {
			return _comptesSociete;
		}// Fin getCompte
		/**
		 * Acces  un compte par son numro
		 * @param n 	le numro du compte recherch
		 * @return le compte qui a le numro n
		 */
		private ComptePerso getCompte(Integer n) {
			return this.getComptes().get(n);
		} // Fin getOuvrage
		
		private Depot getDepot(Integer n) {
			return this.getDepots().get(n);
		} // Fin getOuvrage
		
		private Retrait getRetrait(Integer n) {
			return this.getRetraits().get(n);
		} // Fin getOuvrage
		
		private CompteSociete getCompteSociete(Integer n) {
			return this.getComptesSociete().get(n);
		} // Fin getOuvrage
		/**
		 * @return la vue  
		 */
		private VueMenuBanque getVueMenuBanque() {
			return _vueMenuBanque ;
		}// Fin getVueVueMenuBanque
		
		private VueNouvClient getVueNouvClient() {
			return _vueNouvClient ;
		}// Fin getVueVueNouvClient
		
		private VueNouvCompte getVueNouvCompte() {
			return _vueNouvCompte ;
		}// Fin getVueVueNouvCompte
		
		private VueComptePerso getVueComptePerso() {
			return _vueComptePerso ;
		}// Fin getVueVueNouvCompte
		private VueCompteSociete getVueCompteSociete() {
			return _vueCompteSociete ;
		}
		private VueNouvSociete getVueNouvSociete() {
			return _vueNouvSociete ;
		}// Fin getVueVueNouvClient
		
		private VueNouvCompteSociete getVueNouvCompteSociete() {
			return _vueNouvCompteSociete ;
		}// Fin getVueVueNouvCompte
		
		private VueNouvMandataire getVueNouvMandataire() {
			return _vueNouvMandataire ;
		}// Fin getVueVueNouvCompte
		
		
		private VueDepot getVueDepot() {
			return _vueDepot;
		}// Fin getVueVueMenuBanque
		
		private VueRetrait getVueRetrait() {
			return _vueRetrait;
		}// Fin getVueVueMenuBanque
		
		private VueExtraitCompte getVueExtraitCompte() {
			return _vueExtraitCompte ;
		}// Fin getVueVueMenuBanque
		
		// ************************************************************************************************************
		// Methodes publiques de creation et affichage des fenetres de l'application et fermeture
		// ************************************************************************************************************
		/**
		 * Creation et affichage de la fenetre principale de l'application. 
		 * Elle reste affichee
		 */
		
		public void menuBanque() {
			try {this.setVueMenuBanque(new VueMenuBanque(this));	
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		
		// ************************************************************************************************************
		// Operations liees � l'application en reponse a une action de l'utilisateur dans une vue
		// ************************************************************************************************************
		/**
		 * Creation et affichage de la fenetre de saisie d'un client
		 */
		public void NouvClientPhysique() {
			try {this.setVueNouvClient(new VueNouvClient(this));
			// le Menu est cach�
			this.getVueMenuBanque().getFrame().setVisible(false); 
			// la vue courante est VueNouvClient
				this.getVueNouvClient().setEtat(Vue.initiale);
				this.getVueNouvClient().setVisible(true);
			} catch (Exception e) {
			e.printStackTrace();
			}
		}
		
		public void NouvSociete() {
			try {this.setVueNouvSociete(new VueNouvSociete(this));
			// le Menu est cach�
			this.getVueMenuBanque().getFrame().setVisible(false); 
			// la vue courante est VueNouvClient
				this.getVueNouvSociete().setEtat(Vue.initiale);
				this.getVueNouvSociete().setVisible(true);
			} catch (Exception e) {
			e.printStackTrace();
			}
		}
		public void NouvCompteSociete() {
			try {this.setVueNouvCompteSociete(new VueNouvCompteSociete(this));
			// le Menu est cach�
			this.getVueMenuBanque().getFrame().setVisible(false); 
			// la vue courante est VueNouvClient
				this.getVueNouvCompteSociete().setEtat(Vue.initiale);
				this.getVueNouvCompteSociete().setVisible(true);
			} catch (Exception e) {
			e.printStackTrace();
			}
		}
		public void CompteSociete() {
			try {this.setVueCompteSociete(new VueCompteSociete(this));
			// le Menu est cach�
			this.getVueMenuBanque().getFrame().setVisible(false); 
			// la vue courante est VueNouvClient
				this.getVueCompteSociete().setEtat(Vue.initiale);
				this.getVueCompteSociete().setVisible(true);
			} catch (Exception e) {
			e.printStackTrace();
			}
		}
		/**
		 * Creation d'un nouveau client 
		 * Invoqu� dans VueNouvClient
		 * @param  nom, prenom et adresse du client
		 * affiche un message de confirmation apres l'enregistrement ou un message d'erreur 
		 */
		public void nouvClientPhysique(String nom, String prenom, String adresse, String date) {
			// verification de la presence des infos obligatoires
			boolean inscription;
			if ((nom.length() == 0) || (prenom.length() == 0) || (adresse.length() == 0) || (date.length() == 0)){
				new Dialog().info("Tous les champs sont obligatoires");
				inscription = false;
			}
			else if (this.getClient(nom+prenom)== null) {
				inscription = true;
			}
			else{
				inscription = false;
				new Dialog().info("Un Client du même nom est déjà présent dans la base de donnée.");
			}
			
			if(inscription){
				// Instanciation du client
				GregorianCalendar dn = ESDate.lireDate (date);
				if (dn == null) {
					new Dialog().info("Le format de la date est incorrect");
				}
				else{				
					ClientPhysique clientP = new ClientPhysique(nom, prenom, adresse, dn);
					// Ajout de l'ouvrage dans l'ensemble des clients de la banque
					this.setClient(clientP, nom+prenom);
					
					new Dialog().info("Client enregistre");
					this.fermerVue (this.getVueNouvClient());
				}
			}
		}
		
		/**
		 * Recherche d'un client � partir de son nom et pr�nom  
		 * Invoqu� dans VueNouvCompte
		 * @param  le nom et pr�nom (concat�n�s) du client
		 * affiche un message d'erreur si le client n'existe pas
		 */
		
		public ClientPhysique rechClientPhysique(String np) {
			ClientPhysique clp = this.getClient(np);
			if (clp == null) {
				new Dialog().info("Client inconnu");
			}
			else {
				// la vue courante est VueNouvCompte
				if (this.getVueNouvCompte() != null) {
				// le controleur modifie l'�tat de la vue
					this.getVueNouvCompte().setEtat(Vue.finale);
					this.getVueNouvCompte().alimente(clp);
				}
			}
			return clp;
		} // Fin rechClient
		
		public Societe rechSociete(String n){
			Societe societe = this.getSociete(n);
			if (societe == null) {
				new Dialog().info("Société inconnue");
			}
			else {
				// la vue courante est VueNouvCompte
				if (this.getVueNouvCompteSociete() != null) {
				// le controleur modifie l'�tat de la vue
					this.getVueNouvCompteSociete().setEtat(Vue.finale);
					this.getVueNouvCompteSociete().alimente(societe);
				}
			}
			return societe;
		}
		
		public void rechCompteSociete(String num){
			int n = 0;
			try{
				n = Integer.parseInt(num);
			}
			catch (Exception e){
				new Dialog().info("Le numéro de compte doit être un nombre ([0-9])");
			}
			CompteSociete compte = this.getCompteSociete(n);
			if (compte == null) {
				new Dialog().info("Compte inconnu");
			}
			else {
				// la vue courante est VueNouvCompte
				if (this.getVueNouvMandataire() != null) {
				// le controleur modifie l'�tat de la vue
					this.getVueNouvMandataire().setEtat(Vue.finale);
					this.getVueNouvMandataire().afficheInfos(compte);
				}
			}
		}
		public void rechCompte(String num){
			int n = 0;
			try{
				n = Integer.parseInt(num);
			}
			catch (Exception e){
				new Dialog().info("Le numéro de compte doit être un nombre ([0-9])");
			}
			CompteSociete compteSoc = this.getCompteSociete(n);
			ComptePerso comptePer = this.getCompte(n);
			if (compteSoc != null) {
				if (this.getVueDepot() != null) {
					// le controleur modifie l'etat de la vue
					this.getVueDepot().setEtat(Vue.finale);
					this.getVueDepot().affiche(compteSoc);
					}
			}
			else if(comptePer != null){
				if (this.getVueDepot() != null) {
					// le controleur modifie l'etat de la vue
						this.getVueDepot().setEtat(Vue.finale);
						this.getVueDepot().affiche(comptePer);
					}
			}
			else{
				new Dialog().info("Compte inconnu");
			}
		}
		
		public void rechCompteRetrait(String num){
			int n = 0;
			try{
				n = Integer.parseInt(num);
			}
			catch (Exception e){
				new Dialog().info("Le numéro de compte doit être un nombre ([0-9])");
			}
			CompteSociete compteSoc = this.getCompteSociete(n);
			ComptePerso comptePer = this.getCompte(n);
			if (compteSoc != null) {
				if (this.getVueRetrait() != null) {
					// le controleur modifie l'etat de la vue
					this.getVueRetrait().setEtat(Vue.finale);
					this.getVueRetrait().affiche(compteSoc);
					this.getVueRetrait().alimente(compteSoc.getMandataires());
				}
			}
			else if(comptePer != null){
				if (this.getVueRetrait() != null) {
					// le controleur modifie l'etat de la vue
						this.getVueRetrait().setEtat(Vue.finale);
						this.getVueRetrait().affiche(comptePer);
					}
			}
			else{
				new Dialog().info("Compte inconnu");
			}
		}
		/**
		 * Creation et affichage de la fenetre de saisie d'un compte
		 */ 
		public void NouvComptePerso() {
			try {this.setVueNouvCompte(new VueNouvCompte(this));
			// le Menu est cach�
			this.getVueMenuBanque().getFrame().setVisible(false); 
			// la vue courante est VueNouvCompte
				this.getVueNouvCompte().setEtat(Vue.initiale);
				this.getVueNouvCompte().setVisible(true);
			} catch (Exception e) {
			e.printStackTrace();
			}
		}
		
		public void NouvMandataire() {
			try {this.setVueNouvMandataire(new VueNouvMandataire(this));
			// le Menu est cach�
			this.getVueMenuBanque().getFrame().setVisible(false); 
			// la vue courante est VueNouvCompte
				this.getVueNouvMandataire().setEtat(Vue.initiale);
				this.getVueNouvMandataire().setVisible(true);
			} 
			catch (Exception e) {
				e.printStackTrace();
			}
		}
		
		public void Depot() {
			try {this.setVueDepot(new VueDepot(this));
			// le Menu est cach�
			this.getVueMenuBanque().getFrame().setVisible(false); 
			// la vue courante est VueNouvCompte
				this.getVueDepot().setEtat(Vue.initiale);
				this.getVueDepot().setVisible(true);
			} 
			catch (Exception e) {
				e.printStackTrace();
			}
		}
		public void Retrait() {
			try {this.setVueRetrait(new VueRetrait(this));
			// le Menu est cach�
			this.getVueMenuBanque().getFrame().setVisible(false); 
			// la vue courante est VueNouvCompte
				this.getVueRetrait().setEtat(Vue.initiale);
				this.getVueRetrait().setVisible(true);
			} 
			catch (Exception e) {
				e.printStackTrace();
			}
		}
		/**
		 * Creation d'un nouveau compte 
		 * Invoqu� dans VueNouvCompte
		 * @param  dateEdition la date d'édition de l'ouvrage
		 * affiche un message de confirmation après l'enregistrement ou un message d'erreur 
		 */
		public void nouvComptePerso(String ty, String s, String d, ClientPhysique clp) {
			// verification de la presence des infos obligatoires 
			if ((s.length() == 0) || (ty.length() == 0) || (d.length() == 0)){
					new Dialog().error("Tous les champs sont obligatoires");
			}
			else {
				try{
					int numero = this.genererNumCompte();
					float so = Float.parseFloat(s);
					int dec = Integer.parseInt(d);
					ComptePerso cp = new ComptePerso(numero, ty, so, dec, clp);
					this.setCompte(cp, numero);
					this.getVueNouvCompte().alimenteNum(numero);
					new Dialog().info("Compte enregistré");
					this.fermerVue (this.getVueNouvCompte());
				}
				catch(Exception e){
					new Dialog().error("Erreur avec les données", e.getMessage());
				}
			}
		} // Fin nouvComptePerso
		
		/**
		 * G�n�ration d'un num�ro de compte
		 */
		
		private int genererNumCompte() {
			this.setNumDerCompte(this.getNumDerCompte() + 1);
			return(this.getNumDerCompte());
		}
		
		private int genererNumMouv() {
			this.setNumDermouv(this.getNumDerMouv() + 1);
			return(this.getNumDerCompte());
		}

		public void fermerVue (Vue vue) {
			if (vue instanceof VueMenuBanque ) {	
			// Quitte l'aplication. Sauvegarde les objets du modele
				this.sauve();
				System.exit(0);
				}
			vue.dispose();
			// le Menu est rendu de nouveau visible
			this.getVueMenuBanque().getFrame().setVisible(true);
			this.resetVues();
		}
		
		// Restaure l'etat de l'interface avec seule la fenetre du Menu principal active
		private void resetVues() {
			this.setVueNouvClient (null);
			this.setVueNouvCompte(null);
		}
		
		// ************************************************************************************************************
		// Operations liees a la serialisation des objets de l'application
		// ************************************************************************************************************
		/**
		 *  restauration des objets de l'application
		 */
		public Controleur restaure() {
			try {
				FileInputStream fichier = new FileInputStream("Fsauv.sauv");
				ObjectInputStream in = new ObjectInputStream(fichier);
				return((Controleur) in.readObject());
			} 
			catch (Exception e) {
				new Dialog().error("Pbs de Restauration ou fichier non encore cree "+e.getMessage());
				return this;
			} 
		}
		
		
		/**
		 *  sauvegarde des objets de l'application
		 */
		private void sauve() {
			try {
				FileOutputStream f = new FileOutputStream("Fsauv.sauv");
				ObjectOutputStream out = new ObjectOutputStream(f);
				out.writeObject(this);
			} 
			catch (Exception e) {
				new Dialog().error("Problème de Sauvegarde dans le fichier \n\r"+e.getMessage() + e.getStackTrace());
			}
		}

		
		public void ConsultComptePerso() {
			try{
				this.setVueComptePerso(new VueComptePerso(this));
				// le Menu est caché
				this.getVueMenuBanque().getFrame().setVisible(false); 
				// la vue courante est VueNouvCompte
				this.getVueComptePerso().setEtat(Vue.initiale);
				this.getVueComptePerso().setVisible(true);
			} 
			catch (Exception e) {
				new Dialog().error(e.getMessage());
			}
		}		
		
		public void ConsultCompteSociete() {
			try{
				this.setVueCompteSociete(new VueCompteSociete(this));
				// le Menu est caché
				this.getVueMenuBanque().getFrame().setVisible(false); 
				// la vue courante est VueNouvCompte
				this.getVueCompteSociete().setEtat(Vue.initiale);
				this.getVueCompteSociete().setVisible(true);
			} 
			catch (Exception e) {
				new Dialog().error(e.getMessage());
			}
		}
		
		public void getComptePerso(ClientPhysique client){
			if(client.getComptes().isEmpty()){
				new Dialog().info("Ce client n'as pas de compte dans cette banque.");
			}
			else{
				this.getVueComptePerso().aliment(client.getComptes());				
			}
		}
		
		public void getCompteSociete(Societe societe){
			if(societe.getComptes().isEmpty()){
				new Dialog().info("Cette société n'as pas de compte dans cette banque.");
			}
			else{
				this.getVueCompteSociete().setComptes(societe.getComptes());				
			}
		}
		/**
		 * Implementation de l'algorithme de Luhn.
		 * Permet de vérifier la validité d'un numero de Siren
		 */
		public boolean verifNumSiren(String num){
			String decoupe = "";
			int ispair = num.length();
			for (int i=0;i<num.length();i++){
				int nb = 0;
				if((ispair) % 2 == 0){
					nb = (Integer.parseInt(String.valueOf(num.charAt(i))) * 2);
				}
				else{
					nb = Integer.parseInt(String.valueOf(num.charAt(i)));
				}
				decoupe += nb;
				ispair--;
			}
			int somme = 0;
			for (int i=0;i<decoupe.length();i++){
				somme += Integer.parseInt(String.valueOf(decoupe.charAt(i)));
			}
			
			if(somme % 10 == 0){
				return true;
			}
			else{
				return false;
			}
		}
		

		public Mandataire nouvMandataire(String nom, String prenom, String adresse,
			String dn, float retraitMax, String titre, DroitsMandataire.droits droits, CompteSociete compte) {
			Mandataire mandataire = null;
			if(nom.length()==0 || prenom.length()==0 || adresse.length()==0 || dn.length()==0 || titre.length()==0){
				new Dialog().error("Tout les champs sont obligatoire.");
			}
			else{
				GregorianCalendar dateN = ESDate.lireDate (dn);
				if (dateN == null) {
					new Dialog().error("Le format de la date est incorrect");
				}
				else{	
					if(retraitMax >= 0.0){
						if(this.getMandataire(nom+prenom)== null) {
							mandataire = new Mandataire(nom, prenom, adresse, dateN, titre);
							this.setMandataire(mandataire, nom+prenom);
							// Ajout de la liaison du compte Société
							compte.rajoutMandataire(mandataire, droits, retraitMax);
							new Dialog().info("Mandataire enregistré.");
							this.fermerVue (this.getVueNouvMandataire());
						}
						else{
							new Dialog().info("Un Mandataire du même nom est déjà présent dans la base de donnée.");
						}		
					}
					else{
						new Dialog().error("Le format des limites de dépôt et retrait est incorrect.");
					}
				}
			}
			if(mandataire != null){
				return mandataire;
			}
			else{
				return null;
			}
		}

		public void nouvSociete(String nom, String prenom,
				String nomSociete, String numS, String adresseS) {
				
			if(nomSociete.length() == 0 || numS.length() == 0 || prenom.length() == 0 || nom.length() == 0 || adresseS.length()==0){
				new Dialog().error("Tout les champs sont obligatoire.");
			}
			else{
				//Attention VERIRICATION FAUSSE POUR TEST !!!!!!!!!!!!!!!!!!!!!!!! 
				if(!this.verifNumSiren(numS)){
					Societe societe = new Societe(nomSociete, numS, adresseS, nom, prenom);
					this.setSociete(societe, numS);
					
					new Dialog().info("Société enregistrée");
					this.fermerVue (this.getVueNouvSociete());
				}
				else{
					new Dialog().error("Le Numéro de Siren n'est pas valide.");
				}
			}
		}

		public void nouvCompteSociete(String type, String s, String d, Societe sos) {
			// verification de la presence des infos obligatoires 
			if ((s.length() == 0) || (type.length() == 0) || (d.length() == 0)){
				new Dialog().error("Tous les champs sont obligatoires");
			}
			else {
				try{
					Integer num = this.genererNumCompte();					
					float so = Float.parseFloat(s);
					int dec = Integer.parseInt(d);
					CompteSociete cs = new CompteSociete(num, type, so, dec, sos);
					this.setCompteSociete(cs, num);
					new Dialog().info("Compte enregistré");
					this.fermerVue (this.getVueNouvCompteSociete());
				}
				catch (Exception e){
					new Dialog().error("Erreur avec les données", e.getMessage());
				}
			}
		}


		public void depotSociete(String m, CompteSociete _compteS2, Depot.typeDepot t) {
			if ((m.length() == 0)){
				new Dialog().error("Le montant du dépot est obligatoire");
			}
			else {
				try{
					Integer num = this.genererNumMouv();	
					GregorianCalendar date = ESDate.lireDate ("22/05/2013");
					Float montant = Float.valueOf(m);
					if(montant > 0){
						Depot d = new Depot(num, date, montant, t);
						_compteS2.setDepot(d);
						Float solde = _compteS2.getSolde();
						solde = solde+montant;
						_compteS2.setSolde(solde);
						new Dialog().info("Depot enregistré");
					}
					else{
						new Dialog().error("Veuillez entrer une valeur positive.");
					}
					this.fermerVue (this.getVueDepot());
				}
				catch (Exception e){
					new Dialog().error("Erreur avec les données", e.toString());
				}
			}
		}

		public void depotPerso(String m, ComptePerso _compteP, Depot.typeDepot t) {
			if ((m.length() == 0)){
				new Dialog().error("Le montant du dépot est obligatoire");
			}
			else {
				try{
					Integer num = this.genererNumMouv();	
					GregorianCalendar date = ESDate.lireDate ("22/05/2013");
					Float montant = Float.valueOf(m);
					if(montant > 0){
						Depot d = new Depot(num, date, montant, t);
						_compteP.setDepot(d);
						Float solde = _compteP.getSolde();
						solde = solde+montant;
						_compteP.setSolde(solde);
						new Dialog().info("Depot enregistré");
					}
					else{
						new Dialog().error("Veuillez entrer une valeur positive.");					
					}
					this.fermerVue (this.getVueDepot());
				}
				catch (Exception e){
					new Dialog().error("Erreur avec les données", e.getMessage());
				}
			}
		}

		public void retraitPerso(String m, ComptePerso _compteP, Retrait.typeRetrait t) {
			if ((m.length() == 0)){
				new Dialog().error("Le montant du dépot est obligatoire");
			}
			else {
				try{
					Integer num = this.genererNumMouv();	
					GregorianCalendar date = ESDate.lireDate ("22/05/2013");
					Float montant = Float.valueOf(m);
					if(montant > 0){
						Retrait r = new Retrait(num, date, montant, t);
						_compteP.setRetrait(r);
						if((_compteP.getSolde()-montant) >= (0-_compteP.getDecouvertAutorise())){
							Float solde = _compteP.getSolde();
							solde = solde-montant;
							_compteP.setSolde(solde);
							new Dialog().info("Retrait enregistré");
						}
						else{
							new Dialog().error("Les fonds sont insufisants pour effectuer ce retrait.");
						}
					}
					else{
						new Dialog().error("Veuillez entrer une valeur positive.");
					}
					this.fermerVue (this.getVueRetrait());
				}
				catch (Exception e){
					new Dialog().error("Erreur avec les données", e.getMessage());
				}
			}
		}

		public void retraitSociete(String m, CompteSociete _compteS2,
				Retrait.typeRetrait t, DroitsMandataire droitsMand) {
			if ((m.length() == 0)){
				new Dialog().error("Le montant du dépot est obligatoire");
			}
			else {
				try{
					Integer num = this.genererNumMouv();	
					GregorianCalendar date = ESDate.lireDate ("22/05/2013");
					Float montant = Float.valueOf(m);
					if(montant > 0 ){
						Retrait r = new Retrait(num, date, montant, t);
						_compteS2.setRetrait(r);
						if((droitsMand.getRetraitMax() < montant && droitsMand.getDroits() == DroitsMandataire.droits.A) || droitsMand.getDroits() == DroitsMandataire.droits.A){
							if((_compteS2.getSolde()-montant) >= (0-_compteS2.getDecouvertAutorise())){
								Float solde = _compteS2.getSolde();
								solde = solde-montant;
								_compteS2.setSolde(solde);
								new Dialog().info("Retrait enregistré");
							}
							else{
								new Dialog().error("Les fonds sont insufisants pour effectuer ce retrait.");
							}
						}
						else{
							new Dialog().error("Le mandataire ne peut retirer que"+ droitsMand.getRetraitMax() +"au maximum.");
						}
					}
					else{
						new Dialog().error("Veuillez entrer une valeur positive.");
					}
					this.fermerVue (this.getVueRetrait());
				}
				catch (Exception e){
					new Dialog().error("Erreur avec les données", e.getMessage());
				}
			}			
		}
}

;